home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ggraph / set.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-07  |  10.0 KB  |  351 lines
  1. #include <stdio.h>
  2. #include <errno.h>
  3. #include <strings.h>
  4. #include <math.h>
  5. #include "ggraph.h"
  6. #include "ggraphdefs.h"
  7.  
  8. /* set any unset defaults for lines */
  9. setdefault () {
  10.     register int    i;
  11.     for (curline = 0; ((curline != cg.maxlines) && (cl != NULL)); ++curline) {
  12.     if (!cl->llabsw)
  13.         cl->llabsw = FALSE;
  14.     if (cl->mtype == -1)
  15.         cl->mtype = CROSS;
  16.     if (cl->ltype == -1)
  17.         cl->ltype = BRUSH_NORMAL;
  18.     if (cl->ctype == -1)
  19.         cl->ctype = LINE;
  20.     if(cl->llabel.t_size == -1)
  21.         cl->llabel.t_size = 2;
  22.     if(cl->llabel.t_font == -1)
  23.         cl->llabel.t_font = ROMAN;
  24.     if(cl->llelabel.t_size == -1)
  25.         cl->llelabel.t_size = 2;
  26.     if(cl->llelabel.t_font == -1)
  27.         cl->llelabel.t_font = ROMAN;
  28.     }
  29.     if (cg.gtype == -1)
  30.     cg.gtype = LINEAR;
  31.     if (cg.xpreci1 == -1)
  32.     cg.xpreci1 = 4;
  33.     if (cg.ypreci1 == -1)
  34.     cg.ypreci1 = 4;
  35.     if (cg.symbolsz == -1)
  36.     cg.symbolsz = 3.0;
  37.     if (cg.logxsw == -1)
  38.     cg.logxsw = 0;
  39.     if (cg.logxtick == -1)
  40.     cg.logxtick = 10.0;
  41.     if (cg.logysw == -1)
  42.     cg.logysw = 0;
  43.     if (cg.logytick == -1)
  44.     cg.logytick = 10.0;
  45.     if (cg.gframe.fsize == -1)
  46.     cg.gframe.fsize = BRUSH_THIN;
  47.     if (cg.lframe.fsize == -1)
  48.     cg.lframe.fsize = BRUSH_THIN;
  49.     if (cg.lframe.fsize == -1)
  50.     cg.lframe.fsize = BRUSH_THIN;
  51.     if (cg.gtitle.t_size == -1)
  52.     cg.gtitle.t_size = 3;
  53.     if (cg.xtick.t_size == -1)
  54.     cg.xtick.t_size = 2;
  55.     if (cg.ytick.t_size == -1)
  56.     cg.ytick.t_size = 2;
  57.     if (cg.xlabel.t_size == -1)
  58.     cg.xlabel.t_size = 2;
  59.     if (cg.ylabel.t_size == -1)
  60.     cg.ylabel.t_size = 2;
  61.     if (cg.legend.t_size == -1)
  62.     cg.legend.t_size = 2;
  63.     if (cg.yvert == -1)
  64.     cg.yvert = 1;
  65.     if (cg.gtitle.t_font == -1)
  66.     cg.gtitle.t_font = ROMAN;
  67.     if (cg.legend.t_font == -1)
  68.     cg.legend.t_font = ROMAN;
  69.     if (cg.xlabel.t_font == -1)
  70.     cg.xlabel.t_font = ROMAN;
  71.     if (cg.ylabel.t_font == -1)
  72.     cg.ylabel.t_font = ROMAN;
  73.     if (cg.xtick.t_font == -1)
  74.     cg.xtick.t_font = ROMAN;
  75.     if (cg.ytick.t_font == -1)
  76.     cg.ytick.t_font = ROMAN;
  77.     if (cg.xgrid_type == -1)
  78.     cg.xgrid_type = BRUSH_DOT;
  79.     if (cg.ygrid_type == -1)
  80.     cg.ygrid_type = BRUSH_DOT;
  81.     if (cg.firstxsw == -1)
  82.     cg.firstxsw = 0;
  83.     if (cg.firstysw == -1)
  84.     cg.firstysw = 0;
  85.     if(legendf){
  86.       calc_legend(&cg.xplotmax,&cg.yorigin);    /* figure out lengend stuff */
  87.       cg.yplotmax = YPLOTMAX;
  88.     }else{
  89.       cg.xplotmax = XPLOTMAX;
  90.       cg.yplotmax = YPLOTMAX;
  91.     }
  92.     cg.gframe.frame1x = FRAME1X;    /* set frame boundaries */
  93.     cg.gframe.frame2x = FRAME2X;
  94.     cg.gframe.frame3x = FRAME3X;
  95.     cg.gframe.frame4x = FRAME4X;
  96.     cg.gframe.frame1y = FRAME1Y;
  97.     cg.gframe.frame2y = FRAME2Y;
  98.     cg.gframe.frame3y = FRAME3Y;
  99.     cg.gframe.frame4y = FRAME4Y;
  100. }
  101. /* set the axis limits and centers */
  102. setlim () {
  103.     float   xrange,
  104.             yrange;        /* range along each axis */
  105.     float   xtestr,
  106.             ytestr;        /* range along each axis to test */
  107.     register int    n,
  108.                     factor;
  109.     int     axmax;
  110.     double  pow ();
  111.  
  112.     n = 0;
  113.     if ((cg.dtickx == 0) || (cg.logxsw == 1)) {
  114.     xrange = cg.gmaxx - cg.gminx;
  115.     if (xrange < 1.0)
  116.         factor = -1;
  117.     else
  118.         factor = 1;
  119.     if (factor == 1) {
  120.         while (TRUE) {
  121.         xtestr = pow ((double) 10.0, (double) n);
  122.         if ((xrange / xtestr) < 1.0)
  123.             break;
  124.         n = n + factor;
  125.         }
  126.     }
  127.     else {
  128.         while (TRUE) {
  129.         xtestr = pow ((double) 10.0, (double) n);
  130.         if ((xrange / xtestr) > 1.0) {
  131.             factor = 0;
  132.             break;
  133.         }
  134.         n = n + factor;
  135.         }
  136.         if (cg.xpreci2 == -1)
  137.         cg.xpreci2 = -n + 1;
  138.     }
  139.     cg.dtickx = pow ((double) 10.0, (double) (n - factor));
  140.     axmax = xrange / cg.dtickx;
  141.     if (cg.logxsw) {
  142. if(debug)printf("xmaxtic %d %f\n", cg.maxtickx, cg.stickx);
  143.         if (cg.maxtickx == 0)
  144.         cg.maxtickx = (int) ((log10 ((double) cg.gmaxx) /
  145.                 log10 ((double) cg.logxtick)));
  146.         if (cg.stickx != 0)
  147.         cg.mintickx = cg.xoffset = (int)(log10((double)cg.stickx) /
  148.             log10 ((double) (cg.logxtick)));
  149.         else {
  150.         cg.mintickx = cg.xoffset = (int)(log10((double)cg.gminx) /
  151.             log10 ((double) (cg.logxtick)));
  152.         }
  153.         if (debug){
  154.         printf ("decide1 %f %f\n", cg.gminx, (cg.gmaxx -
  155.                 pow ((double) cg.logxtick, (double) cg.maxtickx)));
  156.         printf ("decide2 %f %f\n", cg.gmaxx, (cg.gminx -
  157.                 pow ((double) cg.logxtick, (double) cg.mintickx)));
  158.         printf ("decide3 %f %f\n", cg.gmaxx, (cg.gminx -
  159.                 (float)pow ((double) cg.logxtick, (double) cg.mintickx)));
  160.         printf ("decide4 %f %f\n", cg.gmaxx, ((double)cg.gminx -
  161.                 pow ((double) cg.logxtick, (double) cg.mintickx)));
  162.         }
  163.         if ((cg.gmaxx - pow ((double) cg.logxtick, (double) cg.maxtickx))
  164.             > 0.0)
  165.         cg.maxtickx++;
  166.         if (cg.stickx == 0.0)
  167.         if ((cg.gminx - (float) pow ((double) cg.logxtick, (double) cg.mintickx))
  168.             < 0.0) {
  169.             cg.mintickx--;
  170.             cg.xoffset--;
  171.         }
  172.         if (!cg.numtickx)
  173.         cg.numtickx = abs ((int) cg.maxtickx - (int) cg.mintickx);
  174.         cg.xoffset = (int) cg.xoffset;
  175.         if (debug)
  176.         printf ("maxt %d mint %d numt %d off %f\n",
  177.           cg.maxtickx, cg.mintickx, cg.numtickx, cg.xoffset);
  178.     }else{
  179.         if (!cg.numtickx)
  180.           if((axmax * cg.dtickx) < xrange)
  181.         cg.numtickx = axmax + 1;
  182.           else
  183.         cg.numtickx = axmax;
  184.           if (!cg.stickx)
  185.         cg.stickx = cg.gminx;
  186.           cg.xoffset = cg.gminx;
  187.     }
  188.     }else
  189.       cg.xoffset = cg.stickx;
  190.     n = 0;
  191.     if ((cg.dticky == 0) || (cg.logysw == 1)) {
  192.     yrange = cg.gmaxy - cg.gminy;
  193.     if (yrange < 1.0)
  194.         factor = -1;
  195.     else
  196.         factor = 1;
  197.     if (factor == 1) {
  198.         while (TRUE) {
  199.         ytestr = pow ((double) 10.0, (double) n);
  200.         if ((yrange / ytestr) < 1.0)
  201.             break;
  202.         n = n + factor;
  203.         }
  204.     }
  205.     else {
  206.         while (TRUE) {
  207.         ytestr = pow ((double) 10.0, (double) n);
  208.         if ((yrange / ytestr) > 1.0) {
  209.             factor = 0;
  210.             break;
  211.         }
  212.         n = n + factor;
  213.         }
  214.         if (cg.ypreci2 == -1)
  215.         cg.ypreci2 = -n + 1;
  216.     }
  217.     cg.dticky = pow ((double) 10.0, (double) (n - factor));
  218.     axmax = yrange / cg.dticky;
  219.     if (cg.logysw) {
  220.         if (cg.maxticky == 0)
  221.         cg.maxticky = (int) ((log10 ((double) cg.gmaxy) /
  222.                 log10 ((double) cg.logytick)));
  223.         if (cg.sticky != 0)
  224.         cg.minticky = cg.yoffset = (int) ((log10 ((double) cg.sticky) /
  225.                 log10 ((double) (cg.logytick))));
  226.         else {
  227.         cg.minticky = cg.yoffset = (int) ((log10 ((double) cg.gminy) /
  228.                 log10 ((double) (cg.logytick))));
  229.         }
  230.         if ((cg.gmaxy - pow ((double) cg.logytick, (double) cg.maxticky))
  231.             > 0.0)
  232.         cg.maxticky++;
  233.         if (debug)
  234.         printf ("decide %f %f\n", cg.gminy, (cg.gminy -
  235.                 pow ((double) cg.logytick, (double) cg.minticky)));
  236.         if (cg.sticky == 0.0)
  237.         if ((cg.gminy - (float) pow ((double) cg.logytick, (double) cg.minticky))
  238.             < 0.0) {
  239.             cg.minticky--;
  240.             cg.yoffset--;
  241.         }
  242.         if (!cg.numticky)
  243.         cg.numticky = abs ((int) cg.maxticky - (int) cg.minticky);
  244.         cg.yoffset = (int) cg.yoffset;
  245.         if (debug)
  246.         printf ("maxt %d mint %d numt %d\n", cg.maxticky, cg.minticky,
  247.             cg.numticky);
  248.     }else{
  249.         if (!cg.numticky)
  250.           if((axmax * cg.dticky) < yrange)
  251.         cg.numticky = axmax + 1;
  252.           else
  253.         cg.numticky = axmax;
  254.           if (!cg.sticky)
  255.         cg.sticky = cg.gminy;
  256.           cg.yoffset = cg.gminy;
  257.     }
  258.     }else
  259.       cg.yoffset = cg.sticky;
  260.     if ((cg.numtickx) < 3 && !cg.logxsw) {
  261.     cg.numtickx = cg.numtickx * 2;
  262.     cg.dtickx = cg.dtickx / 2.0;
  263.     if((cg.dtickx < 1.0)&&(cg.xpreci2 == -1)) {
  264.        cg.xpreci1 = 1;
  265.        cg.xpreci2 = 1;
  266.     }
  267.     }
  268.     if ((cg.numticky < 3) && !cg.logysw) {
  269.     cg.numticky = cg.numticky * 2;
  270.     cg.dticky = cg.dticky / 2.0;
  271.     if((cg.dticky < 1.0)&&(cg.ypreci2 == -1)){
  272.        cg.ypreci1 = 1;
  273.        cg.ypreci2 = 1;
  274.     }
  275.     }
  276. /* to calculate scale -> PLOTMAX - origin > scale*maxtick*dtick */
  277. /* therefore scale = (PLOTMAX - origin)/(maxtick*dtick) */
  278.  /* center is in user units */
  279.     cg.xcenter = (cg.numtickx * cg.dtickx) / 2.0;
  280.     cg.ycenter = (cg.numticky * cg.dticky) / 2.0;
  281.     calc_text(&cg.xorigin, &cg.yorigin);
  282.     if(debug)printf("origins from text %f %f\n", cg.xorigin, cg.yorigin);
  283.     if(debug)printf("X Label %f %f\n", cg.xlabel.t_xpos, cg.xlabel.t_ypos);
  284.     if(debug)printf("Y Label %f %f\n", cg.ylabel.t_xpos, cg.ylabel.t_ypos);
  285.  /* set scale factors */
  286.     cg.scalex = (cg.xplotmax - cg.xorigin) / (cg.numtickx * cg.dtickx);
  287.     cg.scaley = (cg.yplotmax - cg.yorigin) / (cg.numticky * cg.dticky);
  288.     if (debug)
  289.     fprintf (stderr, "dtickx %f maxtick %d stickx %f\n\
  290.  numtick %d scale %f center %f offset %f\n",
  291.         cg.dtickx, cg.maxtickx, cg.stickx, cg.numtickx, 
  292.         cg.scalex, cg.xcenter, cg.xoffset);
  293.     if (debug)
  294.     fprintf (stderr, "dticky %f maxtick %d sticky %f\n\
  295.  numtick %d scale %f center %f offset %f\n",
  296.         cg.dticky, cg.maxticky, cg.sticky, cg.numticky,
  297.         cg.scaley, cg.ycenter, cg.yoffset);
  298.  
  299.  /* title is in device units since it's */
  300.  /* only used once might as well do it here */
  301.  /*    cg.gtitle.t_xpos = (cg.xcenter * cg.scalex) + cg.xorigin - 
  302.     ((cg.xorigin - cg.gframe.frame1x)/2);*/
  303.     if(!cg.gtitle.t_xpos)
  304.         cg.gtitle.t_xpos = ((cg.gframe.frame3x - cg.gframe.frame1x)/2) + 
  305.     cg.gframe.frame1x;
  306.     if(!cg.gtitle.t_ypos)
  307.         cg.gtitle.t_ypos = (cg.numticky * cg.dticky * cg.scaley)
  308.      + cg.yorigin + 25;
  309.     return;
  310. }
  311.  
  312. calc_text(xo, yo)
  313. float *xo, *yo;    /* coords to set */
  314. {
  315.     register int i;
  316.     float textx, texty, height;    /* for computing vertical text */
  317.     char numstr[10];
  318.  
  319.     if (!*xo){
  320.     if(cg.ypreci2 == -1){
  321.         sprintf(numstr, "%d", (int)cg.gmaxy);
  322.         i = strlen(numstr);
  323.     }else
  324.         i = cg.ypreci1 + cg.ypreci2;
  325.     *xo = cg.gframe.frame1x + ycharsz[cg.ylabel.t_size] + /* set origins */
  326.         i * ycharsz[cg.ytick.t_size];
  327.     }
  328.     if (!*yo)
  329.     *yo = cg.gframe.frame1y + (3.0 * ycharsz[cg.xlabel.t_size]);
  330.     if(!cg.xlabel.t_xpos)
  331.       cg.xlabel.t_xpos = (cg.xplotmax - *xo)/2 + *xo;
  332.     if(!cg.xlabel.t_ypos)
  333.       cg.xlabel.t_ypos = *yo - (1.75 * ycharsz[cg.xlabel.t_size]);
  334.     if(!cg.yvert){
  335.     if(!cg.ylabel.t_xpos)
  336.       cg.ylabel.t_xpos = cg.gframe.frame1x+(2*ycharsz[cg.ylabel.t_size]);
  337.     if(!cg.ylabel.t_ypos)
  338.       cg.ylabel.t_ypos = cg.ycenter;
  339.     }else{
  340.     i = strlen(cg.ylabel.t_text) * ycharsz[cg.ylabel.t_size]; /* get length */
  341.     height = YPLOTMAX-*yo;
  342.     texty = *yo + height - ((height - (float)i)/2.0);
  343.     if(!cg.ylabel.t_xpos)
  344.       cg.ylabel.t_xpos = cg.gframe.frame1x+ycharsz[cg.ylabel.t_size];
  345.     if(!cg.ylabel.t_ypos)
  346.       cg.ylabel.t_ypos = texty;
  347.     }
  348.     if (debug)
  349.     fprintf (stderr, "orgs %f %f\n", *xo, *yo);
  350. }
  351.